// app.js
// 导入对象存储工具
const objectStorage = require('./utils/objectStorage');
const storageUtil = require('./utils/storage');
const api = require('./api/index');
const apiConfig = require('./api/config'); // 导入API配置
const tokenManager = require('./utils/tokenManager');
const requestInterceptor = require('./utils/requestInterceptor');

// 初始化请求拦截器
requestInterceptor.setup();

App({
  onLaunch() {
    console.log('小程序启动');
    
    this.globalData = {
      userInfo: null,
      apiBaseUrl: apiConfig.baseURL, // 使用API配置中的baseURL
      tabBarIndex: 0,
      // 对象存储配置
      objectStorage: {
        accessKey: 'a0qepsyj',
        secretKey: 'ggv5qxzbqb42vlvc',
        endpoint: 'objectstorageapi.bja.sealos.run',
        bucketName: 'a0qepsyj-001'
      },
      isLoggedIn: false,
      // 全局事件处理
      events: {},
      // 页面实例集合
      pageInstances: {}
    };
    
    // 设置API基础URL (不需要额外设置，api模块已经使用了config.js中的URL)
    console.log('API基础URL已设置:', apiConfig.baseURL);
    
    // 检查并更新小程序
    this.checkUpdateVersion();

    // 云开发初始化
    if (!wx.cloud) {
      console.error('请使用 2.2.3 或以上的基础库以使用云能力');
    } else {
      wx.cloud.init({
        //   env 参数说明：
        //   env 参数决定接下来小程序发起的云开发调用（wx.cloud.xxx）会默认请求到哪个云环境的资源
        //   此处请填入环境 ID, 环境 ID 可打开云控制台查看
        //   如不填则使用默认环境（第一个创建的环境）
        env: 'job-platform-22a3b', // 使用 AppID 前缀作为云开发环境ID
        traceUser: true,
      });
    }

    // 初始化对象存储并预加载关键资源
    this.initObjectStorage();
    
    // 检查登录状态
    this.checkLoginStatus();
    console.log('登录状态检查完成，当前状态:', this.globalData.isLoggedIn);
  },

  // 初始化对象存储并预加载资源
  initObjectStorage() {
    console.log('初始化对象存储并预加载资源...');
    try {
      // 预加载头像
      ['avatar-d907281-0', 'avatar-d907281-1', 'avatar-d928162-0', 'avatar-d928162-1'].forEach(key => {
        const url = storageUtil.getObjectURL(key);
        console.log(`预加载头像: ${key} -> ${url}`);
        this.preloadImage(url);
      });

      // 预加载图标
      ['plus', 'eye', 'group', 'more', 'icon-system-notice', 'icon-watch-collect', 
       'icon-comments', 'icon-customer-service'].forEach(key => {
        const url = storageUtil.getObjectURL(key);
        console.log(`预加载图标: ${key} -> ${url}`);
        this.preloadImage(url);
      });

      // 预加载banner图
      ['banner1', 'banner2', 'banner3'].forEach(key => {
        const url = storageUtil.getObjectURL(key);
        console.log(`预加载banner: ${key} -> ${url}`);
        this.preloadImage(url);
      });

      console.log('资源预加载完成');
    } catch (error) {
      console.error('资源预加载失败:', error);
    }
  },

  // 预加载图片
  preloadImage(url) {
    return new Promise((resolve, reject) => {
      const img = { src: url };
      img.onload = resolve;
      img.onerror = reject;
      
      // 使用wx.getImageInfo预加载图片
      wx.getImageInfo({
        src: url,
        success: (res) => {
          console.log(`图片预加载成功: ${url}`);
          resolve(res);
        },
        fail: (err) => {
          console.error(`图片预加载失败: ${url}`, err);
          reject(err);
        }
      });
    });
  },

  checkUpdateVersion() {
    const updateManager = wx.getUpdateManager();
    updateManager.onCheckForUpdate((res) => {
      if (res.hasUpdate) {
        updateManager.onUpdateReady(() => {
          wx.showModal({
            title: '更新提示',
            content: '新版本已准备好，是否重启应用？',
            success: (result) => {
              if (result.confirm) {
                updateManager.applyUpdate();
              }
            }
          });
        });
      }
    });
  },

  // 获取对象存储文件URL
  getObjectURL: function(objectKey) {
    return api.storage.getFullObjectUrl(objectKey);
  },

  // 根据文件键名获取对象URL（使用映射）
  getFileURL: function(fileKey) {
    return storageUtil.getObjectURL(fileKey);
  },

  // 上传文件到对象存储
  uploadToObjectStorage: function(filePath, objectKey, contentType) {
    return objectStorage.uploadFile(filePath, objectKey, contentType);
  },

  // 上传图片到对象存储（便捷方法）
  uploadImage: function(options) {
    return objectStorage.uploadImage(options);
  },

  // 清理URL缓存
  clearStorageCache: function(fileKey) {
    storageUtil.clearURLCache(fileKey);
  },

  // 检查用户登录状态
  checkLoginStatus: function() {
    const isLoggedIn = tokenManager.isLoggedIn();
    this.globalData.isLoggedIn = isLoggedIn;
    
    if (isLoggedIn) {
      // 获取用户基本信息
      this.getUserInfo();
    }
  },

  // 获取系统信息
  getSystemInfo: function() {
    const that = this;
    wx.getSystemInfo({
      success: function(res) {
        that.globalData.systemInfo = res;
        // 检测是否为iPhone X系列
        that.globalData.isIphoneX = /iphone x/i.test(res.model) || /iPhone11/i.test(res.model) || /iPhone12/i.test(res.model);
      }
    });
  },

  // 显示导航栏加载状态
  showNavigationBarLoading: function() {
    wx.showNavigationBarLoading();
  },

  // 隐藏导航栏加载状态
  hideNavigationBarLoading: function() {
    wx.hideNavigationBarLoading();
  },

  // 显示加载提示
  showLoading: function(title = '加载中...') {
    wx.showLoading({
      title: title,
      mask: true
    });
  },

  // 隐藏加载提示
  hideLoading: function() {
    wx.hideLoading();
  },

  // 显示成功提示
  showSuccess: function(title, duration = 1500) {
    wx.showToast({
      title: title,
      icon: 'success',
      duration: duration
    });
  },

  // 显示错误提示
  showError: function(title, duration = 1500) {
    wx.showToast({
      title: title,
      icon: 'error',
      duration: duration
    });
  },

  /**
   * 获取用户信息
   */
  async getUserInfo() {
    try {
      console.log('准备获取用户信息');
      const token = tokenManager.getAccessToken();
      if (!token) {
        console.log('没有token，无法获取用户信息');
        return;
      }
      
      console.log('使用token获取用户信息');
      const userInfo = await api.user.getProfile(token);
      console.log('获取到用户信息:', userInfo);
      this.globalData.userInfo = userInfo;
      // 触发用户信息更新事件
      this.triggerEvent('userInfoUpdated', userInfo);
    } catch (error) {
      console.error('获取用户信息失败', error);
      // 如果是401错误，tokenManager已自动处理
    }
  },
  
  /**
   * 登录方法
   * @param {string} code - 微信登录code
   * @param {string} encryptedData - 微信加密数据(可选)
   * @param {string} iv - 加密向量(可选)
   * @returns {Promise} - 登录结果
   */
  async login(code, encryptedData, iv) {
    try {
      console.log('开始登录，code:', code);
      if (encryptedData && iv) {
        console.log('携带加密数据登录');
      } else {
        console.log('仅使用code登录');
      }
      
      const loginResult = await api.auth.wxLogin(code, encryptedData, iv);
      console.log('登录成功，获取到结果:', loginResult);
      
      // 检查登录结果
      if (!loginResult || !loginResult.userId) {
        console.error('登录响应数据格式错误:', loginResult);
        throw new Error('登录响应中缺少用户ID');
      }
      
      // 检测是否为新用户
      const isNewUser = loginResult.isNewUser || false;
      if (isNewUser) {
        console.log('检测到新用户首次登录，userId:', loginResult.userId);
      }
      
      // 保存登录信息
      tokenManager.saveLoginData(loginResult);
      this.globalData.isLoggedIn = true;
      this.globalData.userId = loginResult.userId;
      console.log('登录状态已更新:', this.globalData.isLoggedIn);
      
      // 获取用户详细信息
      try {
        await this.getUserInfo();
      } catch (err) {
        console.warn('获取用户详情失败，但不影响登录流程:', err);
      }
      
      return loginResult;
    } catch (error) {
      console.error('登录失败', error);
      return Promise.reject(error);
    }
  },
  
  /**
   * 注销登录
   * @returns {Promise} - 注销结果
   */
  async logout() {
    try {
      await tokenManager.logout();
      this.globalData.isLoggedIn = false;
      this.globalData.userInfo = null;
      
      // 跳转到登录页
      wx.reLaunch({
        url: '/pages/login/login'
      });
      
      return true;
    } catch (error) {
      console.error('注销失败', error);
      return Promise.reject(error);
    }
  },

  // 更新用户头像
  updateUserAvatar: function(avatarUrl) {
    console.log('更新全局头像', avatarUrl);
    // 确保avatarUrl有效
    if (!avatarUrl) {
      console.error('更新失败: 无效的头像URL');
      return false;
    }
    
    try {
      const storage = require('./utils/storage.js');
      
      // 获取当前用户信息
      let userInfo = wx.getStorageSync('userInfo') || {};
      
      // 更新头像URL并添加时间戳防止缓存
      const timestamp = Date.now();
      const newAvatarUrl = avatarUrl.includes('?') 
        ? `${avatarUrl}&t=${timestamp}` 
        : `${avatarUrl}?t=${timestamp}`;
      
      // 更新用户信息
      userInfo.avatarUrl = newAvatarUrl;
      
      // 保存到本地存储
      wx.setStorageSync('userInfo', userInfo);
      
      // 更新全局数据
      this.globalData.userInfo = userInfo;
      
      // 设置全局标记，表示需要刷新用户信息
      this.globalData.needRefreshUserInfo = true;
      
      // 清除旧头像的缓存
      storage.clearWxImageCache(avatarUrl);
      
      // 强制重新加载图片
      storage.reloadImage(newAvatarUrl)
        .then(() => {
          console.log('头像图片重载成功');
        })
        .catch(err => {
          console.error('头像图片重载失败', err);
        });
      
      // 触发头像更新事件
      this.triggerEvent('avatarUpdate', newAvatarUrl);
      
      // 刷新所有页面
      this.refreshAllPages();
      
      console.log('全局头像已更新:', newAvatarUrl);
      return true;
    } catch(e) {
      console.error('更新头像失败:', e);
      return false;
    }
  },
  
  // 注册页面实例
  registerPageInstance: function(pageInstance) {
    try {
      const pages = getCurrentPages();
      const currentPage = pages[pages.length - 1];
      const pageName = currentPage.route;
      
      console.log(`注册页面实例: ${pageName}`);
      this.globalData.pageInstances[pageName] = pageInstance;
    } catch (e) {
      console.error('注册页面实例失败:', e);
    }
  },
  
  // 卸载页面实例
  unregisterPageInstance: function(pageInstance) {
    try {
      const pages = getCurrentPages();
      // 尝试获取当前页面，如果页面已关闭则可能获取不到
      let pageName = '';
      if (pages.length > 0) {
        const currentPage = pages[pages.length - 1];
        pageName = currentPage.route;
      } else {
        // 尝试查找匹配的实例
        for (const key in this.globalData.pageInstances) {
          if (this.globalData.pageInstances[key] === pageInstance) {
            pageName = key;
            break;
          }
        }
      }
      
      if (pageName) {
        console.log(`卸载页面实例: ${pageName}`);
        delete this.globalData.pageInstances[pageName];
      }
    } catch (e) {
      console.error('卸载页面实例失败:', e);
    }
  },
  
  // 刷新所有已注册页面的用户信息
  refreshAllPages: function(eventData) {
    const pages = this.globalData.pageInstances;
    for (const pageName in pages) {
      const page = pages[pageName];
      if (page && typeof page.refreshUserInfo === 'function') {
        console.log(`正在刷新页面 ${pageName} 的用户信息`);
        page.refreshUserInfo(eventData);
      } else if (page && typeof page.getUserInfo === 'function') {
        console.log(`正在刷新页面 ${pageName} 的用户信息`);
        page.getUserInfo(eventData);
      } else if (page && typeof page.getUserInfoFromStorage === 'function') {
        console.log(`正在刷新页面 ${pageName} 的用户信息`);
        page.getUserInfoFromStorage(eventData);
      }
    }
  },
  
  /**
   * 触发自定义事件
   * @param {string} eventName - 事件名称 
   * @param {Object} eventData - 事件数据
   */
  triggerEvent: function(eventName, eventData) {
    if (!eventName) {
      console.error('触发事件失败: 未提供事件名称');
      return;
    }
    
    console.log(`触发事件: ${eventName}`, eventData);
    
    // 获取该事件的所有回调
    const callbacks = this.globalData.events[eventName] || [];
    
    // 执行所有回调
    callbacks.forEach(callback => {
      try {
        callback(eventData);
      } catch (err) {
        console.error(`执行事件 ${eventName} 回调时出错:`, err);
      }
    });
    
    // 如果是通用更新事件，刷新所有注册页面
    if (eventName === 'userInfoUpdated') {
      this.refreshAllPages(eventData);
    }
  },
  
  /**
   * 注册事件监听
   * @param {string} eventName - 事件名称
   * @param {Function} callback - 回调函数 
   * @return {Function} - 用于注销监听的函数
   */
  onEvent: function(eventName, callback) {
    if (!eventName || typeof callback !== 'function') {
      console.error('注册事件失败: 未提供事件名称或回调函数');
      return () => {};
    }
    
    // 初始化事件数组（如果不存在）
    if (!this.globalData.events[eventName]) {
      this.globalData.events[eventName] = [];
    }
    
    // 添加到事件回调数组
    this.globalData.events[eventName].push(callback);
    
    console.log(`已注册事件监听: ${eventName}`);
    
    // 返回注销监听的函数
    return () => {
      const callbacks = this.globalData.events[eventName] || [];
      const index = callbacks.indexOf(callback);
      if (index !== -1) {
        callbacks.splice(index, 1);
        console.log(`已注销事件监听: ${eventName}`);
      }
    };
  },

  // 对外暴露API接口
  api
});
